﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Terraria.DataStructures;
using Terraria.GameInput;
using Terraria.ModLoader.Default;
using Terraria.ModLoader.IO;

namespace Terraria.ModLoader
{
	// Token: 0x0200025A RID: 602
	public static class PlayerHooks
	{
		// Token: 0x06001916 RID: 6422 RVA: 0x0042200C File Offset: 0x0042020C
		private static PlayerHooks.HookList AddHook<F>(Expression<Func<ModPlayer, F>> func)
		{
			PlayerHooks.HookList hookList = new PlayerHooks.HookList(ModLoader.Method<ModPlayer, F>(func));
			PlayerHooks.hooks.Add(hookList);
			return hookList;
		}

		// Token: 0x06001917 RID: 6423 RVA: 0x00422034 File Offset: 0x00420234
		internal static void Add(ModPlayer player)
		{
			player.index = PlayerHooks.players.Count;
			PlayerHooks.indexes[player.mod.Name + ":" + player.Name] = PlayerHooks.players.Count;
			if (PlayerHooks.indexesByType.ContainsKey(player.GetType()))
			{
				PlayerHooks.indexesByType[player.GetType()] = -1;
			}
			else
			{
				PlayerHooks.indexesByType[player.GetType()] = PlayerHooks.players.Count;
			}
			PlayerHooks.players.Add(player);
		}

		// Token: 0x06001918 RID: 6424 RVA: 0x004220CC File Offset: 0x004202CC
		internal static void RebuildHooks()
		{
			foreach (PlayerHooks.HookList hookList in PlayerHooks.hooks)
			{
				hookList.arr = (from p in ModLoader.BuildGlobalHook<ModPlayer>(PlayerHooks.players, hookList.method)
				select p.index).ToArray<int>();
			}
		}

		// Token: 0x06001919 RID: 6425 RVA: 0x000123AC File Offset: 0x000105AC
		internal static void Unload()
		{
			PlayerHooks.players.Clear();
			PlayerHooks.indexes.Clear();
			PlayerHooks.indexesByType.Clear();
		}

		// Token: 0x0600191A RID: 6426 RVA: 0x00422158 File Offset: 0x00420358
		internal static void SetupPlayer(Player player)
		{
			player.modPlayers = (from modPlayer in PlayerHooks.players
			select modPlayer.CreateFor(player)).ToArray<ModPlayer>();
		}

		// Token: 0x0600191B RID: 6427 RVA: 0x00422198 File Offset: 0x00420398
		internal static ModPlayer GetModPlayer(Player player, Mod mod, string name)
		{
			int num;
			if (!PlayerHooks.indexes.TryGetValue(mod.Name + ":" + name, out num))
			{
				return null;
			}
			return player.modPlayers[num];
		}

		// Token: 0x0600191C RID: 6428 RVA: 0x004221D0 File Offset: 0x004203D0
		internal static ModPlayer GetModPlayer(Player player, Type type)
		{
			int num;
			if (!PlayerHooks.indexesByType.TryGetValue(type, out num))
			{
				return null;
			}
			if (num <= -1)
			{
				return null;
			}
			return player.modPlayers[num];
		}

		// Token: 0x0600191D RID: 6429 RVA: 0x004221FC File Offset: 0x004203FC
		public static void ResetEffects(Player player)
		{
			foreach (int num in PlayerHooks.HookResetEffects.arr)
			{
				player.modPlayers[num].ResetEffects();
			}
		}

		// Token: 0x0600191E RID: 6430 RVA: 0x00422234 File Offset: 0x00420434
		public static void UpdateDead(Player player)
		{
			foreach (int num in PlayerHooks.HookUpdateDead.arr)
			{
				player.modPlayers[num].UpdateDead();
			}
		}

		// Token: 0x0600191F RID: 6431 RVA: 0x0042226C File Offset: 0x0042046C
		public static IList<Item> SetupStartInventory(Player player)
		{
			IList<Item> list = new List<Item>();
			Item item = new Item();
			item.SetDefaults(3507, false);
			item.Prefix(-1);
			list.Add(item);
			item = new Item();
			item.SetDefaults(3509, false);
			item.Prefix(-1);
			list.Add(item);
			item = new Item();
			item.SetDefaults(3506, false);
			item.Prefix(-1);
			list.Add(item);
			foreach (int num in PlayerHooks.HookSetupStartInventory.arr)
			{
				player.modPlayers[num].SetupStartInventory(list);
			}
			IDictionary<int, int> dictionary = new Dictionary<int, int>();
			foreach (Item item2 in list)
			{
				if (item2.maxStack > 1)
				{
					if (!dictionary.ContainsKey(item2.netID))
					{
						dictionary[item2.netID] = 0;
					}
					IDictionary<int, int> dictionary2 = dictionary;
					int key = item2.netID;
					dictionary2[key] += item2.stack;
				}
			}
			int j = 0;
			while (j < list.Count)
			{
				bool flag = true;
				int netID = list[j].netID;
				if (dictionary.ContainsKey(netID))
				{
					list[j].stack = dictionary[netID];
					if (list[j].stack > list[j].maxStack)
					{
						list[j].stack = list[j].maxStack;
					}
					IDictionary<int, int> dictionary2 = dictionary;
					int key = netID;
					dictionary2[key] -= list[j].stack;
					if (list[j].stack <= 0)
					{
						list.RemoveAt(j);
						flag = false;
					}
				}
				if (flag)
				{
					j++;
				}
			}
			return list;
		}

		// Token: 0x06001920 RID: 6432 RVA: 0x00422464 File Offset: 0x00420664
		public static void SetStartInventory(Player player, IList<Item> items)
		{
			if (items.Count <= 50)
			{
				for (int i = 0; i < items.Count; i++)
				{
					player.inventory[i] = items[i];
				}
				return;
			}
			for (int j = 0; j < 49; j++)
			{
				player.inventory[j] = items[j];
			}
			Item item = new Item();
			item.SetDefaults(ModLoader.GetMod("ModLoader").ItemType("StartBag"), false);
			for (int k = 49; k < items.Count; k++)
			{
				((StartBag)item.modItem).AddItem(items[k]);
			}
			player.inventory[49] = item;
		}

		// Token: 0x06001921 RID: 6433 RVA: 0x000123CC File Offset: 0x000105CC
		public static void SetStartInventory(Player player)
		{
			PlayerHooks.SetStartInventory(player, PlayerHooks.SetupStartInventory(player));
		}

		// Token: 0x06001922 RID: 6434 RVA: 0x0042250C File Offset: 0x0042070C
		public static void PreSavePlayer(Player player)
		{
			foreach (int num in PlayerHooks.HookPreSavePlayer.arr)
			{
				player.modPlayers[num].PreSavePlayer();
			}
		}

		// Token: 0x06001923 RID: 6435 RVA: 0x00422544 File Offset: 0x00420744
		public static void PostSavePlayer(Player player)
		{
			foreach (int num in PlayerHooks.HookPostSavePlayer.arr)
			{
				player.modPlayers[num].PostSavePlayer();
			}
		}

		// Token: 0x06001924 RID: 6436 RVA: 0x0042257C File Offset: 0x0042077C
		public static void UpdateBiomes(Player player)
		{
			foreach (int num in PlayerHooks.HookUpdateBiomes.arr)
			{
				player.modPlayers[num].UpdateBiomes();
			}
		}

		// Token: 0x06001925 RID: 6437 RVA: 0x004225B4 File Offset: 0x004207B4
		public static bool CustomBiomesMatch(Player player, Player other)
		{
			foreach (int num in PlayerHooks.HookCustomBiomesMatch.arr)
			{
				if (!player.modPlayers[num].CustomBiomesMatch(other))
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x06001926 RID: 6438 RVA: 0x004225F4 File Offset: 0x004207F4
		public static void CopyCustomBiomesTo(Player player, Player other)
		{
			foreach (int num in PlayerHooks.HookCopyCustomBiomesTo.arr)
			{
				player.modPlayers[num].CopyCustomBiomesTo(other);
			}
		}

		// Token: 0x06001927 RID: 6439 RVA: 0x0042262C File Offset: 0x0042082C
		public static void SendCustomBiomes(Player player, BinaryWriter writer)
		{
			ushort num = 0;
			byte[] buffer;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
				{
					foreach (int num2 in PlayerHooks.HookSendCustomBiomes.arr)
					{
						if (PlayerHooks.SendCustomBiomes(player.modPlayers[num2], binaryWriter))
						{
							num += 1;
						}
					}
					binaryWriter.Flush();
					buffer = memoryStream.ToArray();
				}
			}
			writer.Write(num);
			writer.Write(buffer);
		}

		// Token: 0x06001928 RID: 6440 RVA: 0x004226D4 File Offset: 0x004208D4
		private static bool SendCustomBiomes(ModPlayer modPlayer, BinaryWriter writer)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
				{
					modPlayer.SendCustomBiomes(binaryWriter);
					binaryWriter.Flush();
					array = memoryStream.ToArray();
				}
			}
			if (array.Length != 0)
			{
				writer.Write(modPlayer.mod.Name);
				writer.Write(modPlayer.Name);
				writer.Write((byte)array.Length);
				writer.Write(array);
				return true;
			}
			return false;
		}

		// Token: 0x06001929 RID: 6441 RVA: 0x0042276C File Offset: 0x0042096C
		public static void ReceiveCustomBiomes(Player player, BinaryReader reader)
		{
			int num = (int)reader.ReadUInt16();
			for (int i = 0; i < num; i++)
			{
				string name = reader.ReadString();
				string name2 = reader.ReadString();
				byte[] buffer = reader.ReadBytes((int)reader.ReadByte());
				Mod mod = ModLoader.GetMod(name);
				ModPlayer modPlayer = (mod == null) ? null : player.GetModPlayer(mod, name2);
				if (modPlayer != null)
				{
					using (MemoryStream memoryStream = new MemoryStream(buffer))
					{
						using (BinaryReader binaryReader = new BinaryReader(memoryStream))
						{
							try
							{
								modPlayer.ReceiveCustomBiomes(binaryReader);
							}
							catch
							{
							}
						}
					}
				}
			}
		}

		// Token: 0x0600192A RID: 6442 RVA: 0x00422828 File Offset: 0x00420A28
		public static void UpdateBiomeVisuals(Player player)
		{
			foreach (int num in PlayerHooks.HookUpdateBiomeVisuals.arr)
			{
				player.modPlayers[num].UpdateBiomeVisuals();
			}
		}

		// Token: 0x0600192B RID: 6443 RVA: 0x00422860 File Offset: 0x00420A60
		public static void clientClone(Player player, Player clientClone)
		{
			foreach (int num in PlayerHooks.HookClientClone.arr)
			{
				player.modPlayers[num].clientClone(clientClone.modPlayers[num]);
			}
		}

		// Token: 0x0600192C RID: 6444 RVA: 0x004228A0 File Offset: 0x00420AA0
		public static void SyncPlayer(Player player, int toWho, int fromWho, bool newPlayer)
		{
			foreach (int num in PlayerHooks.HookSyncPlayer.arr)
			{
				player.modPlayers[num].SyncPlayer(toWho, fromWho, newPlayer);
			}
		}

		// Token: 0x0600192D RID: 6445 RVA: 0x004228DC File Offset: 0x00420ADC
		public static void SendClientChanges(Player player, Player clientPlayer)
		{
			foreach (int num in PlayerHooks.HookSendClientChanges.arr)
			{
				player.modPlayers[num].SendClientChanges(clientPlayer.modPlayers[num]);
			}
		}

		// Token: 0x0600192E RID: 6446 RVA: 0x0042291C File Offset: 0x00420B1C
		public static Texture2D GetMapBackgroundImage(Player player)
		{
			Texture2D texture2D = null;
			foreach (int num in PlayerHooks.HookGetMapBackgroundImage.arr)
			{
				texture2D = player.modPlayers[num].GetMapBackgroundImage();
				if (texture2D != null)
				{
					return texture2D;
				}
			}
			return texture2D;
		}

		// Token: 0x0600192F RID: 6447 RVA: 0x0042295C File Offset: 0x00420B5C
		public static void UpdateBadLifeRegen(Player player)
		{
			foreach (int num in PlayerHooks.HookUpdateBadLifeRegen.arr)
			{
				player.modPlayers[num].UpdateBadLifeRegen();
			}
		}

		// Token: 0x06001930 RID: 6448 RVA: 0x00422994 File Offset: 0x00420B94
		public static void UpdateLifeRegen(Player player)
		{
			foreach (int num in PlayerHooks.HookUpdateLifeRegen.arr)
			{
				player.modPlayers[num].UpdateLifeRegen();
			}
		}

		// Token: 0x06001931 RID: 6449 RVA: 0x004229CC File Offset: 0x00420BCC
		public static void NaturalLifeRegen(Player player, ref float regen)
		{
			foreach (int num in PlayerHooks.HookNaturalLifeRegen.arr)
			{
				player.modPlayers[num].NaturalLifeRegen(ref regen);
			}
		}

		// Token: 0x06001932 RID: 6450 RVA: 0x00422A04 File Offset: 0x00420C04
		public static void PreUpdate(Player player)
		{
			foreach (int num in PlayerHooks.HookPreUpdate.arr)
			{
				player.modPlayers[num].PreUpdate();
			}
		}

		// Token: 0x06001933 RID: 6451 RVA: 0x00422A3C File Offset: 0x00420C3C
		public static void SetControls(Player player)
		{
			foreach (int num in PlayerHooks.HookSetControls.arr)
			{
				player.modPlayers[num].SetControls();
			}
		}

		// Token: 0x06001934 RID: 6452 RVA: 0x00422A74 File Offset: 0x00420C74
		public static void PreUpdateBuffs(Player player)
		{
			foreach (int num in PlayerHooks.HookPreUpdateBuffs.arr)
			{
				player.modPlayers[num].PreUpdateBuffs();
			}
		}

		// Token: 0x06001935 RID: 6453 RVA: 0x00422AAC File Offset: 0x00420CAC
		public static void PostUpdateBuffs(Player player)
		{
			foreach (int num in PlayerHooks.HookPostUpdateBuffs.arr)
			{
				player.modPlayers[num].PostUpdateBuffs();
			}
		}

		// Token: 0x06001936 RID: 6454 RVA: 0x00422AE4 File Offset: 0x00420CE4
		public static void UpdateEquips(Player player, ref bool wallSpeedBuff, ref bool tileSpeedBuff, ref bool tileRangeBuff)
		{
			foreach (int num in PlayerHooks.HookUpdateEquips.arr)
			{
				player.modPlayers[num].UpdateEquips(ref wallSpeedBuff, ref tileSpeedBuff, ref tileRangeBuff);
			}
		}

		// Token: 0x06001937 RID: 6455 RVA: 0x00422B20 File Offset: 0x00420D20
		public static void UpdateVanityAccessories(Player player)
		{
			foreach (int num in PlayerHooks.HookUpdateVanityAccessories.arr)
			{
				player.modPlayers[num].UpdateVanityAccessories();
			}
		}

		// Token: 0x06001938 RID: 6456 RVA: 0x00422B58 File Offset: 0x00420D58
		public static void PostUpdateEquips(Player player)
		{
			foreach (int num in PlayerHooks.HookPostUpdateEquips.arr)
			{
				player.modPlayers[num].PostUpdateEquips();
			}
		}

		// Token: 0x06001939 RID: 6457 RVA: 0x00422B90 File Offset: 0x00420D90
		public static void PostUpdateMiscEffects(Player player)
		{
			foreach (int num in PlayerHooks.HookPostUpdateMiscEffects.arr)
			{
				player.modPlayers[num].PostUpdateMiscEffects();
			}
		}

		// Token: 0x0600193A RID: 6458 RVA: 0x00422BC8 File Offset: 0x00420DC8
		public static void PostUpdateRunSpeeds(Player player)
		{
			foreach (int num in PlayerHooks.HookPostUpdateRunSpeeds.arr)
			{
				player.modPlayers[num].PostUpdateRunSpeeds();
			}
		}

		// Token: 0x0600193B RID: 6459 RVA: 0x00422C00 File Offset: 0x00420E00
		public static void PreUpdateMovement(Player player)
		{
			foreach (int num in PlayerHooks.HookPreUpdateMovement.arr)
			{
				player.modPlayers[num].PreUpdateMovement();
			}
		}

		// Token: 0x0600193C RID: 6460 RVA: 0x00422C38 File Offset: 0x00420E38
		public static void PostUpdate(Player player)
		{
			foreach (int num in PlayerHooks.HookPostUpdate.arr)
			{
				player.modPlayers[num].PostUpdate();
			}
		}

		// Token: 0x0600193D RID: 6461 RVA: 0x00422C70 File Offset: 0x00420E70
		public static void FrameEffects(Player player)
		{
			foreach (int num in PlayerHooks.HookFrameEffects.arr)
			{
				player.modPlayers[num].FrameEffects();
			}
		}

		// Token: 0x0600193E RID: 6462 RVA: 0x00422CA8 File Offset: 0x00420EA8
		public static bool PreHurt(Player player, bool pvp, bool quiet, ref int damage, ref int hitDirection, ref bool crit, ref bool customDamage, ref bool playSound, ref bool genGore, ref PlayerDeathReason damageSource)
		{
			bool result = true;
			foreach (int num in PlayerHooks.HookPreHurt.arr)
			{
				if (!player.modPlayers[num].PreHurt(pvp, quiet, ref damage, ref hitDirection, ref crit, ref customDamage, ref playSound, ref genGore, ref damageSource))
				{
					result = false;
				}
			}
			return result;
		}

		// Token: 0x0600193F RID: 6463 RVA: 0x00422CF8 File Offset: 0x00420EF8
		public static void Hurt(Player player, bool pvp, bool quiet, double damage, int hitDirection, bool crit)
		{
			foreach (int num in PlayerHooks.HookHurt.arr)
			{
				player.modPlayers[num].Hurt(pvp, quiet, damage, hitDirection, crit);
			}
		}

		// Token: 0x06001940 RID: 6464 RVA: 0x00422D38 File Offset: 0x00420F38
		public static void PostHurt(Player player, bool pvp, bool quiet, double damage, int hitDirection, bool crit)
		{
			foreach (int num in PlayerHooks.HookPostHurt.arr)
			{
				player.modPlayers[num].PostHurt(pvp, quiet, damage, hitDirection, crit);
			}
		}

		// Token: 0x06001941 RID: 6465 RVA: 0x00422D78 File Offset: 0x00420F78
		public static bool PreKill(Player player, double damage, int hitDirection, bool pvp, ref bool playSound, ref bool genGore, ref PlayerDeathReason damageSource)
		{
			bool result = true;
			foreach (int num in PlayerHooks.HookPreKill.arr)
			{
				if (!player.modPlayers[num].PreKill(damage, hitDirection, pvp, ref playSound, ref genGore, ref damageSource))
				{
					result = false;
				}
			}
			return result;
		}

		// Token: 0x06001942 RID: 6466 RVA: 0x00422DC0 File Offset: 0x00420FC0
		public static void Kill(Player player, double damage, int hitDirection, bool pvp, PlayerDeathReason damageSource)
		{
			foreach (int num in PlayerHooks.HookKill.arr)
			{
				player.modPlayers[num].Kill(damage, hitDirection, pvp, damageSource);
			}
		}

		// Token: 0x06001943 RID: 6467 RVA: 0x00422DFC File Offset: 0x00420FFC
		public static bool PreItemCheck(Player player)
		{
			foreach (int num in PlayerHooks.HookPreItemCheck.arr)
			{
				if (!player.modPlayers[num].PreItemCheck())
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x06001944 RID: 6468 RVA: 0x00422E38 File Offset: 0x00421038
		public static void PostItemCheck(Player player)
		{
			foreach (int num in PlayerHooks.HookPostItemCheck.arr)
			{
				player.modPlayers[num].PostItemCheck();
			}
		}

		// Token: 0x06001945 RID: 6469 RVA: 0x00422E70 File Offset: 0x00421070
		public static float UseTimeMultiplier(Player player, Item item)
		{
			float num = 1f;
			if (item.IsAir)
			{
				return num;
			}
			foreach (int num2 in PlayerHooks.HookUseTimeMultiplier.arr)
			{
				num *= player.modPlayers[num2].UseTimeMultiplier(item);
			}
			return num;
		}

		// Token: 0x06001946 RID: 6470 RVA: 0x000123DA File Offset: 0x000105DA
		public static float TotalUseTimeMultiplier(Player player, Item item)
		{
			return PlayerHooks.UseTimeMultiplier(player, item) * ItemLoader.UseTimeMultiplier(item, player);
		}

		// Token: 0x06001947 RID: 6471 RVA: 0x00422EBC File Offset: 0x004210BC
		public static float MeleeSpeedMultiplier(Player player, Item item)
		{
			float num = 1f;
			if (item.IsAir)
			{
				return num;
			}
			foreach (int num2 in PlayerHooks.HookMeleeSpeedMultiplier.arr)
			{
				num *= player.modPlayers[num2].MeleeSpeedMultiplier(item);
			}
			return num;
		}

		// Token: 0x06001948 RID: 6472 RVA: 0x000123EB File Offset: 0x000105EB
		public static float TotalMeleeSpeedMultiplier(Player player, Item item)
		{
			return PlayerHooks.TotalUseTimeMultiplier(player, item) * PlayerHooks.MeleeSpeedMultiplier(player, item) * ItemLoader.MeleeSpeedMultiplier(item, player);
		}

		// Token: 0x06001949 RID: 6473 RVA: 0x00422F08 File Offset: 0x00421108
		public static void GetWeaponDamage(Player player, Item item, ref int damage)
		{
			if (item.IsAir)
			{
				return;
			}
			foreach (int num in PlayerHooks.HookGetWeaponDamage.arr)
			{
				player.modPlayers[num].GetWeaponDamage(item, ref damage);
			}
		}

		// Token: 0x0600194A RID: 6474 RVA: 0x00422F4C File Offset: 0x0042114C
		public static void ProcessTriggers(Player player, TriggersSet triggersSet)
		{
			foreach (int num in PlayerHooks.HookProcessTriggers.arr)
			{
				player.modPlayers[num].ProcessTriggers(triggersSet);
			}
		}

		// Token: 0x0600194B RID: 6475 RVA: 0x00422F84 File Offset: 0x00421184
		public static void GetWeaponKnockback(Player player, Item item, ref float knockback)
		{
			if (item.IsAir)
			{
				return;
			}
			foreach (int num in PlayerHooks.HookGetWeaponKnockback.arr)
			{
				player.modPlayers[num].GetWeaponKnockback(item, ref knockback);
			}
		}

		// Token: 0x0600194C RID: 6476 RVA: 0x00422FC8 File Offset: 0x004211C8
		public static void GetWeaponCrit(Player player, Item item, ref int crit)
		{
			if (item.IsAir)
			{
				return;
			}
			foreach (int num in PlayerHooks.HookGetWeaponCrit.arr)
			{
				player.modPlayers[num].GetWeaponCrit(item, ref crit);
			}
		}

		// Token: 0x0600194D RID: 6477 RVA: 0x0042300C File Offset: 0x0042120C
		public static bool ConsumeAmmo(Player player, Item weapon, Item ammo)
		{
			foreach (int num in PlayerHooks.HookConsumeAmmo.arr)
			{
				if (!player.modPlayers[num].ConsumeAmmo(weapon, ammo))
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x0600194E RID: 6478 RVA: 0x0042304C File Offset: 0x0042124C
		public static void OnConsumeAmmo(Player player, Item weapon, Item ammo)
		{
			foreach (int num in PlayerHooks.HookOnConsumeAmmo.arr)
			{
				player.modPlayers[num].OnConsumeAmmo(weapon, ammo);
			}
		}

		// Token: 0x0600194F RID: 6479 RVA: 0x00423088 File Offset: 0x00421288
		public static bool Shoot(Player player, Item item, ref Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack)
		{
			foreach (int num in PlayerHooks.HookShoot.arr)
			{
				if (!player.modPlayers[num].Shoot(item, ref position, ref speedX, ref speedY, ref type, ref damage, ref knockBack))
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x06001950 RID: 6480 RVA: 0x004230D0 File Offset: 0x004212D0
		public static void MeleeEffects(Player player, Item item, Rectangle hitbox)
		{
			foreach (int num in PlayerHooks.HookMeleeEffects.arr)
			{
				player.modPlayers[num].MeleeEffects(item, hitbox);
			}
		}

		// Token: 0x06001951 RID: 6481 RVA: 0x0042310C File Offset: 0x0042130C
		public static void OnHitAnything(Player player, float x, float y, Entity victim)
		{
			foreach (int num in PlayerHooks.HookOnHitAnything.arr)
			{
				player.modPlayers[num].OnHitAnything(x, y, victim);
			}
		}

		// Token: 0x06001952 RID: 6482 RVA: 0x00423148 File Offset: 0x00421348
		public static bool? CanHitNPC(Player player, Item item, NPC target)
		{
			bool? result = null;
			foreach (int num in PlayerHooks.HookCanHitNPC.arr)
			{
				bool? flag = player.modPlayers[num].CanHitNPC(item, target);
				if (flag != null && !flag.Value)
				{
					return new bool?(false);
				}
				if (flag != null)
				{
					result = new bool?(flag.Value);
				}
			}
			return result;
		}

		// Token: 0x06001953 RID: 6483 RVA: 0x004231BC File Offset: 0x004213BC
		public static void ModifyHitNPC(Player player, Item item, NPC target, ref int damage, ref float knockback, ref bool crit)
		{
			foreach (int num in PlayerHooks.HookModifyHitNPC.arr)
			{
				player.modPlayers[num].ModifyHitNPC(item, target, ref damage, ref knockback, ref crit);
			}
		}

		// Token: 0x06001954 RID: 6484 RVA: 0x004231FC File Offset: 0x004213FC
		public static void OnHitNPC(Player player, Item item, NPC target, int damage, float knockback, bool crit)
		{
			foreach (int num in PlayerHooks.HookOnHitNPC.arr)
			{
				player.modPlayers[num].OnHitNPC(item, target, damage, knockback, crit);
			}
		}

		// Token: 0x06001955 RID: 6485 RVA: 0x0042323C File Offset: 0x0042143C
		public static bool? CanHitNPCWithProj(Projectile proj, NPC target)
		{
			if (proj.npcProj || proj.trap)
			{
				return null;
			}
			Player player = Main.player[proj.owner];
			bool? result = null;
			foreach (int num in PlayerHooks.HookCanHitNPCWithProj.arr)
			{
				bool? flag = player.modPlayers[num].CanHitNPCWithProj(proj, target);
				if (flag != null && !flag.Value)
				{
					return new bool?(false);
				}
				if (flag != null)
				{
					result = new bool?(flag.Value);
				}
			}
			return result;
		}

		// Token: 0x06001956 RID: 6486 RVA: 0x004232E0 File Offset: 0x004214E0
		public static void ModifyHitNPCWithProj(Projectile proj, NPC target, ref int damage, ref float knockback, ref bool crit, ref int hitDirection)
		{
			if (proj.npcProj || proj.trap)
			{
				return;
			}
			Player player = Main.player[proj.owner];
			foreach (int num in PlayerHooks.HookModifyHitNPCWithProj.arr)
			{
				player.modPlayers[num].ModifyHitNPCWithProj(proj, target, ref damage, ref knockback, ref crit, ref hitDirection);
			}
		}

		// Token: 0x06001957 RID: 6487 RVA: 0x00423340 File Offset: 0x00421540
		public static void OnHitNPCWithProj(Projectile proj, NPC target, int damage, float knockback, bool crit)
		{
			if (proj.npcProj || proj.trap)
			{
				return;
			}
			Player player = Main.player[proj.owner];
			foreach (int num in PlayerHooks.HookOnHitNPCWithProj.arr)
			{
				player.modPlayers[num].OnHitNPCWithProj(proj, target, damage, knockback, crit);
			}
		}

		// Token: 0x06001958 RID: 6488 RVA: 0x0042339C File Offset: 0x0042159C
		public static bool CanHitPvp(Player player, Item item, Player target)
		{
			foreach (int num in PlayerHooks.HookCanHitPvp.arr)
			{
				if (!player.modPlayers[num].CanHitPvp(item, target))
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x06001959 RID: 6489 RVA: 0x004233DC File Offset: 0x004215DC
		public static void ModifyHitPvp(Player player, Item item, Player target, ref int damage, ref bool crit)
		{
			foreach (int num in PlayerHooks.HookModifyHitPvp.arr)
			{
				player.modPlayers[num].ModifyHitPvp(item, target, ref damage, ref crit);
			}
		}

		// Token: 0x0600195A RID: 6490 RVA: 0x00423418 File Offset: 0x00421618
		public static void OnHitPvp(Player player, Item item, Player target, int damage, bool crit)
		{
			foreach (int num in PlayerHooks.HookOnHitPvp.arr)
			{
				player.modPlayers[num].OnHitPvp(item, target, damage, crit);
			}
		}

		// Token: 0x0600195B RID: 6491 RVA: 0x00423454 File Offset: 0x00421654
		public static bool CanHitPvpWithProj(Projectile proj, Player target)
		{
			Player player = Main.player[proj.owner];
			foreach (int num in PlayerHooks.HookCanHitPvpWithProj.arr)
			{
				if (!player.modPlayers[num].CanHitPvpWithProj(proj, target))
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x0600195C RID: 6492 RVA: 0x004234A0 File Offset: 0x004216A0
		public static void ModifyHitPvpWithProj(Projectile proj, Player target, ref int damage, ref bool crit)
		{
			Player player = Main.player[proj.owner];
			foreach (int num in PlayerHooks.HookModifyHitPvpWithProj.arr)
			{
				player.modPlayers[num].ModifyHitPvpWithProj(proj, target, ref damage, ref crit);
			}
		}

		// Token: 0x0600195D RID: 6493 RVA: 0x004234E8 File Offset: 0x004216E8
		public static void OnHitPvpWithProj(Projectile proj, Player target, int damage, bool crit)
		{
			Player player = Main.player[proj.owner];
			foreach (int num in PlayerHooks.HookOnHitPvpWithProj.arr)
			{
				player.modPlayers[num].OnHitPvpWithProj(proj, target, damage, crit);
			}
		}

		// Token: 0x0600195E RID: 6494 RVA: 0x00423530 File Offset: 0x00421730
		public static bool CanBeHitByNPC(Player player, NPC npc, ref int cooldownSlot)
		{
			foreach (int num in PlayerHooks.HookCanBeHitByNPC.arr)
			{
				if (!player.modPlayers[num].CanBeHitByNPC(npc, ref cooldownSlot))
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x0600195F RID: 6495 RVA: 0x00423570 File Offset: 0x00421770
		public static void ModifyHitByNPC(Player player, NPC npc, ref int damage, ref bool crit)
		{
			foreach (int num in PlayerHooks.HookModifyHitByNPC.arr)
			{
				player.modPlayers[num].ModifyHitByNPC(npc, ref damage, ref crit);
			}
		}

		// Token: 0x06001960 RID: 6496 RVA: 0x004235AC File Offset: 0x004217AC
		public static void OnHitByNPC(Player player, NPC npc, int damage, bool crit)
		{
			foreach (int num in PlayerHooks.HookOnHitByNPC.arr)
			{
				player.modPlayers[num].OnHitByNPC(npc, damage, crit);
			}
		}

		// Token: 0x06001961 RID: 6497 RVA: 0x004235E8 File Offset: 0x004217E8
		public static bool CanBeHitByProjectile(Player player, Projectile proj)
		{
			foreach (int num in PlayerHooks.HookCanBeHitByProjectile.arr)
			{
				if (!player.modPlayers[num].CanBeHitByProjectile(proj))
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x06001962 RID: 6498 RVA: 0x00423628 File Offset: 0x00421828
		public static void ModifyHitByProjectile(Player player, Projectile proj, ref int damage, ref bool crit)
		{
			foreach (int num in PlayerHooks.HookModifyHitByProjectile.arr)
			{
				player.modPlayers[num].ModifyHitByProjectile(proj, ref damage, ref crit);
			}
		}

		// Token: 0x06001963 RID: 6499 RVA: 0x00423664 File Offset: 0x00421864
		public static void OnHitByProjectile(Player player, Projectile proj, int damage, bool crit)
		{
			foreach (int num in PlayerHooks.HookOnHitByProjectile.arr)
			{
				player.modPlayers[num].OnHitByProjectile(proj, damage, crit);
			}
		}

		// Token: 0x06001964 RID: 6500 RVA: 0x004236A0 File Offset: 0x004218A0
		public static void CatchFish(Player player, Item fishingRod, int power, int liquidType, int poolSize, int worldLayer, int questFish, ref int caughtType, ref bool junk)
		{
			int num = 0;
			while (num < 58 && (player.inventory[num].stack <= 0 || player.inventory[num].bait <= 0))
			{
				num++;
			}
			foreach (int num2 in PlayerHooks.HookCatchFish.arr)
			{
				player.modPlayers[num2].CatchFish(fishingRod, player.inventory[num], power, liquidType, poolSize, worldLayer, questFish, ref caughtType, ref junk);
			}
		}

		// Token: 0x06001965 RID: 6501 RVA: 0x0042371C File Offset: 0x0042191C
		public static void GetFishingLevel(Player player, Item fishingRod, Item bait, ref int fishingLevel)
		{
			foreach (int num in PlayerHooks.HookGetFishingLevel.arr)
			{
				player.modPlayers[num].GetFishingLevel(fishingRod, bait, ref fishingLevel);
			}
		}

		// Token: 0x06001966 RID: 6502 RVA: 0x00423758 File Offset: 0x00421958
		public static void AnglerQuestReward(Player player, float rareMultiplier, List<Item> rewardItems)
		{
			foreach (int num in PlayerHooks.HookAnglerQuestReward.arr)
			{
				player.modPlayers[num].AnglerQuestReward(rareMultiplier, rewardItems);
			}
		}

		// Token: 0x06001967 RID: 6503 RVA: 0x00423794 File Offset: 0x00421994
		public static void GetDyeTraderReward(Player player, List<int> rewardPool)
		{
			foreach (int num in PlayerHooks.HookGetDyeTraderReward.arr)
			{
				player.modPlayers[num].GetDyeTraderReward(rewardPool);
			}
		}

		// Token: 0x06001968 RID: 6504 RVA: 0x004237CC File Offset: 0x004219CC
		public static void DrawEffects(PlayerDrawInfo drawInfo, ref float r, ref float g, ref float b, ref float a, ref bool fullBright)
		{
			ModPlayer[] modPlayers = drawInfo.drawPlayer.modPlayers;
			foreach (int num in PlayerHooks.HookDrawEffects.arr)
			{
				modPlayers[num].DrawEffects(drawInfo, ref r, ref g, ref b, ref a, ref fullBright);
			}
		}

		// Token: 0x06001969 RID: 6505 RVA: 0x00423814 File Offset: 0x00421A14
		public static void ModifyDrawInfo(ref PlayerDrawInfo drawInfo)
		{
			ModPlayer[] modPlayers = drawInfo.drawPlayer.modPlayers;
			foreach (int num in PlayerHooks.HookModifyDrawInfo.arr)
			{
				modPlayers[num].ModifyDrawInfo(ref drawInfo);
			}
		}

		// Token: 0x0600196A RID: 6506 RVA: 0x00423854 File Offset: 0x00421A54
		public static List<PlayerLayer> GetDrawLayers(Player drawPlayer)
		{
			List<PlayerLayer> list = new List<PlayerLayer>();
			list.Add(PlayerLayer.HairBack);
			list.Add(PlayerLayer.MountBack);
			list.Add(PlayerLayer.MiscEffectsBack);
			list.Add(PlayerLayer.BackAcc);
			list.Add(PlayerLayer.Wings);
			list.Add(PlayerLayer.BalloonAcc);
			list.Add(PlayerLayer.Skin);
			if (drawPlayer.wearsRobe)
			{
				list.Add(PlayerLayer.ShoeAcc);
				list.Add(PlayerLayer.Legs);
			}
			else
			{
				list.Add(PlayerLayer.Legs);
				list.Add(PlayerLayer.ShoeAcc);
			}
			list.Add(PlayerLayer.Body);
			list.Add(PlayerLayer.HandOffAcc);
			list.Add(PlayerLayer.WaistAcc);
			list.Add(PlayerLayer.NeckAcc);
			list.Add(PlayerLayer.Face);
			list.Add(PlayerLayer.Hair);
			list.Add(PlayerLayer.Head);
			list.Add(PlayerLayer.FaceAcc);
			if (drawPlayer.mount.Cart)
			{
				list.Add(PlayerLayer.ShieldAcc);
				list.Add(PlayerLayer.MountFront);
			}
			else
			{
				list.Add(PlayerLayer.MountFront);
				list.Add(PlayerLayer.ShieldAcc);
			}
			list.Add(PlayerLayer.SolarShield);
			list.Add(PlayerLayer.HeldProjBack);
			list.Add(PlayerLayer.HeldItem);
			list.Add(PlayerLayer.Arms);
			list.Add(PlayerLayer.HandOnAcc);
			list.Add(PlayerLayer.HeldProjFront);
			list.Add(PlayerLayer.FrontAcc);
			list.Add(PlayerLayer.MiscEffectsFront);
			foreach (PlayerLayer playerLayer in list)
			{
				playerLayer.visible = true;
			}
			foreach (int num in PlayerHooks.HookModifyDrawLayers.arr)
			{
				drawPlayer.modPlayers[num].ModifyDrawLayers(list);
			}
			return list;
		}

		// Token: 0x0600196B RID: 6507 RVA: 0x00423A4C File Offset: 0x00421C4C
		public static List<PlayerHeadLayer> GetDrawHeadLayers(Player drawPlayer)
		{
			List<PlayerHeadLayer> list = new List<PlayerHeadLayer>();
			list.Add(PlayerHeadLayer.Head);
			list.Add(PlayerHeadLayer.Hair);
			list.Add(PlayerHeadLayer.AltHair);
			list.Add(PlayerHeadLayer.Armor);
			list.Add(PlayerHeadLayer.FaceAcc);
			foreach (PlayerHeadLayer playerHeadLayer in list)
			{
				playerHeadLayer.visible = true;
			}
			foreach (int num in PlayerHooks.HookModifyDrawHeadLayers.arr)
			{
				drawPlayer.modPlayers[num].ModifyDrawHeadLayers(list);
			}
			return list;
		}

		// Token: 0x0600196C RID: 6508 RVA: 0x00423B0C File Offset: 0x00421D0C
		public static void ModifyScreenPosition(Player player)
		{
			foreach (int num in PlayerHooks.HookModifyScreenPosition.arr)
			{
				player.modPlayers[num].ModifyScreenPosition();
			}
		}

		// Token: 0x0600196D RID: 6509 RVA: 0x00423B44 File Offset: 0x00421D44
		public static void ModifyZoom(Player player, ref float zoom)
		{
			foreach (int num in PlayerHooks.HookModifyZoom.arr)
			{
				player.modPlayers[num].ModifyZoom(ref zoom);
			}
		}

		// Token: 0x0600196E RID: 6510 RVA: 0x00423B7C File Offset: 0x00421D7C
		public static void PlayerConnect(int playerIndex)
		{
			Player player = Main.player[playerIndex];
			foreach (int num in PlayerHooks.HookPlayerConnect.arr)
			{
				player.modPlayers[num].PlayerConnect(player);
			}
		}

		// Token: 0x0600196F RID: 6511 RVA: 0x00423BBC File Offset: 0x00421DBC
		public static void PlayerDisconnect(int playerIndex)
		{
			Player player = Main.player[playerIndex];
			foreach (int num in PlayerHooks.HookPlayerDisconnect.arr)
			{
				player.modPlayers[num].PlayerDisconnect(player);
			}
		}

		// Token: 0x06001970 RID: 6512 RVA: 0x00423BFC File Offset: 0x00421DFC
		public static void OnEnterWorld(int playerIndex)
		{
			Player player = Main.player[playerIndex];
			foreach (int num in PlayerHooks.HookOnEnterWorld.arr)
			{
				player.modPlayers[num].OnEnterWorld(player);
			}
		}

		// Token: 0x06001971 RID: 6513 RVA: 0x00423C3C File Offset: 0x00421E3C
		public static void OnRespawn(Player player)
		{
			foreach (int num in PlayerHooks.HookOnRespawn.arr)
			{
				player.modPlayers[num].OnRespawn(player);
			}
		}

		// Token: 0x06001972 RID: 6514 RVA: 0x00423C74 File Offset: 0x00421E74
		public static bool ShiftClickSlot(Player player, Item[] inventory, int context, int slot)
		{
			foreach (int num in PlayerHooks.HookShiftClickSlot.arr)
			{
				if (player.modPlayers[num].ShiftClickSlot(inventory, context, slot))
				{
					return true;
				}
			}
			return false;
		}

		// Token: 0x06001973 RID: 6515 RVA: 0x00012404 File Offset: 0x00010604
		private static bool HasMethod(Type t, string method, params Type[] args)
		{
			return t.GetMethod(method, args).DeclaringType != typeof(ModPlayer);
		}

		// Token: 0x06001974 RID: 6516 RVA: 0x00423CB4 File Offset: 0x00421EB4
		internal static void VerifyGlobalItem(ModPlayer player)
		{
			Type type = player.GetType();
			int num = 0;
			if (PlayerHooks.HasMethod(type, "CustomBiomesMatch", new Type[]
			{
				typeof(Player)
			}))
			{
				num++;
			}
			if (PlayerHooks.HasMethod(type, "CopyCustomBiomesTo", new Type[]
			{
				typeof(Player)
			}))
			{
				num++;
			}
			if (PlayerHooks.HasMethod(type, "SendCustomBiomes", new Type[]
			{
				typeof(BinaryWriter)
			}))
			{
				num++;
			}
			if (PlayerHooks.HasMethod(type, "ReceiveCustomBiomes", new Type[]
			{
				typeof(BinaryReader)
			}))
			{
				num++;
			}
			if (num > 0 && num < 4)
			{
				throw new Exception(type + " must override all of (CustomBiomesMatch/CopyCustomBiomesTo/SendCustomBiomes/ReceiveCustomBiomes) or none");
			}
			int num2 = 0;
			if (PlayerHooks.HasMethod(type, "clientClone", new Type[]
			{
				typeof(ModPlayer)
			}))
			{
				num2++;
			}
			if (PlayerHooks.HasMethod(type, "SyncPlayer", new Type[]
			{
				typeof(int),
				typeof(int),
				typeof(bool)
			}))
			{
				num2++;
			}
			if (PlayerHooks.HasMethod(type, "SendClientChanges", new Type[]
			{
				typeof(ModPlayer)
			}))
			{
				num2++;
			}
			if (num2 > 0 && num2 < 3)
			{
				throw new Exception(type + " must override all of (clientClone/SyncPlayer/SendClientChanges) or none");
			}
			int num3 = 0;
			if (PlayerHooks.HasMethod(type, "Save", new Type[0]))
			{
				num3++;
			}
			if (PlayerHooks.HasMethod(type, "Load", new Type[]
			{
				typeof(TagCompound)
			}))
			{
				num3++;
			}
			if (num3 == 1)
			{
				throw new Exception(type + " must override all of (Save/Load) or none");
			}
			int num4 = 0;
			if (PlayerHooks.HasMethod(type, "NetSend", new Type[]
			{
				typeof(BinaryWriter)
			}))
			{
				num4++;
			}
			if (PlayerHooks.HasMethod(type, "NetReceive", new Type[]
			{
				typeof(BinaryReader)
			}))
			{
				num4++;
			}
			if (num4 == 1)
			{
				throw new Exception(type + " must override both of (NetSend/NetReceive) or none");
			}
		}

		// Token: 0x040016EF RID: 5871
		private static readonly IList<ModPlayer> players = new List<ModPlayer>();

		// Token: 0x040016F0 RID: 5872
		private static readonly IDictionary<string, int> indexes = new Dictionary<string, int>();

		// Token: 0x040016F1 RID: 5873
		private static readonly IDictionary<Type, int> indexesByType = new Dictionary<Type, int>();

		// Token: 0x040016F2 RID: 5874
		private static List<PlayerHooks.HookList> hooks = new List<PlayerHooks.HookList>();

		// Token: 0x040016F3 RID: 5875
		private static PlayerHooks.HookList HookResetEffects = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.ResetEffects())));

		// Token: 0x040016F4 RID: 5876
		private static PlayerHooks.HookList HookUpdateDead = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.UpdateDead())));

		// Token: 0x040016F5 RID: 5877
		private static PlayerHooks.HookList HookSetupStartInventory = PlayerHooks.AddHook<Action<List<Item>>>((ModPlayer p) => (Action<List<Item>>)Delegate.CreateDelegate(typeof(Action<List<Item>>), p, methodof(ModPlayer.SetupStartInventory(IList<Item>))));

		// Token: 0x040016F6 RID: 5878
		private static PlayerHooks.HookList HookPreSavePlayer = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PreSavePlayer())));

		// Token: 0x040016F7 RID: 5879
		private static PlayerHooks.HookList HookPostSavePlayer = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PostSavePlayer())));

		// Token: 0x040016F8 RID: 5880
		private static PlayerHooks.HookList HookUpdateBiomes = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.UpdateBiomes())));

		// Token: 0x040016F9 RID: 5881
		private static PlayerHooks.HookList HookCustomBiomesMatch = PlayerHooks.AddHook<Func<Player, bool>>((ModPlayer p) => (Func<Player, bool>)Delegate.CreateDelegate(typeof(Func<Player, bool>), p, methodof(ModPlayer.CustomBiomesMatch(Player))));

		// Token: 0x040016FA RID: 5882
		private static PlayerHooks.HookList HookCopyCustomBiomesTo = PlayerHooks.AddHook<Action<Player>>((ModPlayer p) => (Action<Player>)Delegate.CreateDelegate(typeof(Action<Player>), p, methodof(ModPlayer.CopyCustomBiomesTo(Player))));

		// Token: 0x040016FB RID: 5883
		private static PlayerHooks.HookList HookSendCustomBiomes = PlayerHooks.AddHook<Action<BinaryWriter>>((ModPlayer p) => (Action<BinaryWriter>)Delegate.CreateDelegate(typeof(Action<BinaryWriter>), p, methodof(ModPlayer.SendCustomBiomes(BinaryWriter))));

		// Token: 0x040016FC RID: 5884
		private static PlayerHooks.HookList HookUpdateBiomeVisuals = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.UpdateBiomeVisuals())));

		// Token: 0x040016FD RID: 5885
		private static PlayerHooks.HookList HookClientClone = PlayerHooks.AddHook<Action<ModPlayer>>((ModPlayer p) => (Action<ModPlayer>)Delegate.CreateDelegate(typeof(Action<ModPlayer>), p, methodof(ModPlayer.clientClone(ModPlayer))));

		// Token: 0x040016FE RID: 5886
		private static PlayerHooks.HookList HookSyncPlayer = PlayerHooks.AddHook<Action<int, int, bool>>((ModPlayer p) => (Action<int, int, bool>)Delegate.CreateDelegate(typeof(Action<int, int, bool>), p, methodof(ModPlayer.SyncPlayer(int, int, bool))));

		// Token: 0x040016FF RID: 5887
		private static PlayerHooks.HookList HookSendClientChanges = PlayerHooks.AddHook<Action<ModPlayer>>((ModPlayer p) => (Action<ModPlayer>)Delegate.CreateDelegate(typeof(Action<ModPlayer>), p, methodof(ModPlayer.SendClientChanges(ModPlayer))));

		// Token: 0x04001700 RID: 5888
		private static PlayerHooks.HookList HookGetMapBackgroundImage = PlayerHooks.AddHook<Func<Texture2D>>((ModPlayer p) => (Func<Texture2D>)Delegate.CreateDelegate(typeof(Func<Texture2D>), p, methodof(ModPlayer.GetMapBackgroundImage())));

		// Token: 0x04001701 RID: 5889
		private static PlayerHooks.HookList HookUpdateBadLifeRegen = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.UpdateBadLifeRegen())));

		// Token: 0x04001702 RID: 5890
		private static PlayerHooks.HookList HookUpdateLifeRegen = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.UpdateLifeRegen())));

		// Token: 0x04001703 RID: 5891
		private static PlayerHooks.HookList HookNaturalLifeRegen = PlayerHooks.AddHook<PlayerHooks.DelegateNaturalLifeRegen>((ModPlayer p) => (PlayerHooks.DelegateNaturalLifeRegen)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateNaturalLifeRegen), p, methodof(ModPlayer.NaturalLifeRegen(float*))));

		// Token: 0x04001704 RID: 5892
		private static PlayerHooks.HookList HookPreUpdate = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PreUpdate())));

		// Token: 0x04001705 RID: 5893
		private static PlayerHooks.HookList HookSetControls = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.SetControls())));

		// Token: 0x04001706 RID: 5894
		private static PlayerHooks.HookList HookPreUpdateBuffs = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PreUpdateBuffs())));

		// Token: 0x04001707 RID: 5895
		private static PlayerHooks.HookList HookPostUpdateBuffs = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PostUpdateBuffs())));

		// Token: 0x04001708 RID: 5896
		private static PlayerHooks.HookList HookUpdateEquips = PlayerHooks.AddHook<PlayerHooks.DelegateUpdateEquips>((ModPlayer p) => (PlayerHooks.DelegateUpdateEquips)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateUpdateEquips), p, methodof(ModPlayer.UpdateEquips(bool*, bool*, bool*))));

		// Token: 0x04001709 RID: 5897
		private static PlayerHooks.HookList HookUpdateVanityAccessories = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.UpdateVanityAccessories())));

		// Token: 0x0400170A RID: 5898
		private static PlayerHooks.HookList HookPostUpdateEquips = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PostUpdateEquips())));

		// Token: 0x0400170B RID: 5899
		private static PlayerHooks.HookList HookPostUpdateMiscEffects = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PostUpdateMiscEffects())));

		// Token: 0x0400170C RID: 5900
		private static PlayerHooks.HookList HookPostUpdateRunSpeeds = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PostUpdateRunSpeeds())));

		// Token: 0x0400170D RID: 5901
		private static PlayerHooks.HookList HookPreUpdateMovement = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PreUpdateMovement())));

		// Token: 0x0400170E RID: 5902
		private static PlayerHooks.HookList HookPostUpdate = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PostUpdate())));

		// Token: 0x0400170F RID: 5903
		private static PlayerHooks.HookList HookFrameEffects = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.FrameEffects())));

		// Token: 0x04001710 RID: 5904
		private static PlayerHooks.HookList HookPreHurt = PlayerHooks.AddHook<PlayerHooks.DelegatePreHurt>((ModPlayer p) => (PlayerHooks.DelegatePreHurt)Delegate.CreateDelegate(typeof(PlayerHooks.DelegatePreHurt), p, methodof(ModPlayer.PreHurt(bool, bool, int*, int*, bool*, bool*, bool*, bool*, PlayerDeathReason*))));

		// Token: 0x04001711 RID: 5905
		private static PlayerHooks.HookList HookHurt = PlayerHooks.AddHook<Action<bool, bool, double, int, bool>>((ModPlayer p) => (Action<bool, bool, double, int, bool>)Delegate.CreateDelegate(typeof(Action<bool, bool, double, int, bool>), p, methodof(ModPlayer.Hurt(bool, bool, double, int, bool))));

		// Token: 0x04001712 RID: 5906
		private static PlayerHooks.HookList HookPostHurt = PlayerHooks.AddHook<Action<bool, bool, double, int, bool>>((ModPlayer p) => (Action<bool, bool, double, int, bool>)Delegate.CreateDelegate(typeof(Action<bool, bool, double, int, bool>), p, methodof(ModPlayer.PostHurt(bool, bool, double, int, bool))));

		// Token: 0x04001713 RID: 5907
		private static PlayerHooks.HookList HookPreKill = PlayerHooks.AddHook<PlayerHooks.DelegatePreKill>((ModPlayer p) => (PlayerHooks.DelegatePreKill)Delegate.CreateDelegate(typeof(PlayerHooks.DelegatePreKill), p, methodof(ModPlayer.PreKill(double, int, bool, bool*, bool*, PlayerDeathReason*))));

		// Token: 0x04001714 RID: 5908
		private static PlayerHooks.HookList HookKill = PlayerHooks.AddHook<Action<double, int, bool, PlayerDeathReason>>((ModPlayer p) => (Action<double, int, bool, PlayerDeathReason>)Delegate.CreateDelegate(typeof(Action<double, int, bool, PlayerDeathReason>), p, methodof(ModPlayer.Kill(double, int, bool, PlayerDeathReason))));

		// Token: 0x04001715 RID: 5909
		private static PlayerHooks.HookList HookPreItemCheck = PlayerHooks.AddHook<Func<bool>>((ModPlayer p) => (Func<bool>)Delegate.CreateDelegate(typeof(Func<bool>), p, methodof(ModPlayer.PreItemCheck())));

		// Token: 0x04001716 RID: 5910
		private static PlayerHooks.HookList HookPostItemCheck = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.PostItemCheck())));

		// Token: 0x04001717 RID: 5911
		private static PlayerHooks.HookList HookUseTimeMultiplier = PlayerHooks.AddHook<Func<Item, float>>((ModPlayer p) => (Func<Item, float>)Delegate.CreateDelegate(typeof(Func<Item, float>), p, methodof(ModPlayer.UseTimeMultiplier(Item))));

		// Token: 0x04001718 RID: 5912
		private static PlayerHooks.HookList HookMeleeSpeedMultiplier = PlayerHooks.AddHook<Func<Item, float>>((ModPlayer p) => (Func<Item, float>)Delegate.CreateDelegate(typeof(Func<Item, float>), p, methodof(ModPlayer.MeleeSpeedMultiplier(Item))));

		// Token: 0x04001719 RID: 5913
		private static PlayerHooks.HookList HookGetWeaponDamage = PlayerHooks.AddHook<PlayerHooks.DelegateGetWeaponDamage>((ModPlayer p) => (PlayerHooks.DelegateGetWeaponDamage)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateGetWeaponDamage), p, methodof(ModPlayer.GetWeaponDamage(Item, int*))));

		// Token: 0x0400171A RID: 5914
		private static PlayerHooks.HookList HookProcessTriggers = PlayerHooks.AddHook<Action<TriggersSet>>((ModPlayer p) => (Action<TriggersSet>)Delegate.CreateDelegate(typeof(Action<TriggersSet>), p, methodof(ModPlayer.ProcessTriggers(TriggersSet))));

		// Token: 0x0400171B RID: 5915
		private static PlayerHooks.HookList HookGetWeaponKnockback = PlayerHooks.AddHook<PlayerHooks.DelegateGetWeaponKnockback>((ModPlayer p) => (PlayerHooks.DelegateGetWeaponKnockback)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateGetWeaponKnockback), p, methodof(ModPlayer.GetWeaponKnockback(Item, float*))));

		// Token: 0x0400171C RID: 5916
		private static PlayerHooks.HookList HookGetWeaponCrit = PlayerHooks.AddHook<PlayerHooks.DelegateGetWeaponCrit>((ModPlayer p) => (PlayerHooks.DelegateGetWeaponCrit)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateGetWeaponCrit), p, methodof(ModPlayer.GetWeaponCrit(Item, int*))));

		// Token: 0x0400171D RID: 5917
		private static PlayerHooks.HookList HookConsumeAmmo = PlayerHooks.AddHook<Func<Item, Item, bool>>((ModPlayer p) => (Func<Item, Item, bool>)Delegate.CreateDelegate(typeof(Func<Item, Item, bool>), p, methodof(ModPlayer.ConsumeAmmo(Item, Item))));

		// Token: 0x0400171E RID: 5918
		private static PlayerHooks.HookList HookOnConsumeAmmo = PlayerHooks.AddHook<Action<Item, Item>>((ModPlayer p) => (Action<Item, Item>)Delegate.CreateDelegate(typeof(Action<Item, Item>), p, methodof(ModPlayer.OnConsumeAmmo(Item, Item))));

		// Token: 0x0400171F RID: 5919
		private static PlayerHooks.HookList HookShoot = PlayerHooks.AddHook<PlayerHooks.DelegateShoot>((ModPlayer p) => (PlayerHooks.DelegateShoot)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateShoot), p, methodof(ModPlayer.Shoot(Item, Vector2*, float*, float*, int*, int*, float*))));

		// Token: 0x04001720 RID: 5920
		private static PlayerHooks.HookList HookMeleeEffects = PlayerHooks.AddHook<Action<Item, Rectangle>>((ModPlayer p) => (Action<Item, Rectangle>)Delegate.CreateDelegate(typeof(Action<Item, Rectangle>), p, methodof(ModPlayer.MeleeEffects(Item, Rectangle))));

		// Token: 0x04001721 RID: 5921
		private static PlayerHooks.HookList HookOnHitAnything = PlayerHooks.AddHook<Action<float, float, Entity>>((ModPlayer p) => (Action<float, float, Entity>)Delegate.CreateDelegate(typeof(Action<float, float, Entity>), p, methodof(ModPlayer.OnHitAnything(float, float, Entity))));

		// Token: 0x04001722 RID: 5922
		private static PlayerHooks.HookList HookCanHitNPC = PlayerHooks.AddHook<Func<Item, NPC, bool?>>((ModPlayer p) => (Func<Item, NPC, bool?>)Delegate.CreateDelegate(typeof(Func<Item, NPC, bool?>), p, methodof(ModPlayer.CanHitNPC(Item, NPC))));

		// Token: 0x04001723 RID: 5923
		private static PlayerHooks.HookList HookModifyHitNPC = PlayerHooks.AddHook<PlayerHooks.DelegateModifyHitNPC>((ModPlayer p) => (PlayerHooks.DelegateModifyHitNPC)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateModifyHitNPC), p, methodof(ModPlayer.ModifyHitNPC(Item, NPC, int*, float*, bool*))));

		// Token: 0x04001724 RID: 5924
		private static PlayerHooks.HookList HookOnHitNPC = PlayerHooks.AddHook<Action<Item, NPC, int, float, bool>>((ModPlayer p) => (Action<Item, NPC, int, float, bool>)Delegate.CreateDelegate(typeof(Action<Item, NPC, int, float, bool>), p, methodof(ModPlayer.OnHitNPC(Item, NPC, int, float, bool))));

		// Token: 0x04001725 RID: 5925
		private static PlayerHooks.HookList HookCanHitNPCWithProj = PlayerHooks.AddHook<Func<Projectile, NPC, bool?>>((ModPlayer p) => (Func<Projectile, NPC, bool?>)Delegate.CreateDelegate(typeof(Func<Projectile, NPC, bool?>), p, methodof(ModPlayer.CanHitNPCWithProj(Projectile, NPC))));

		// Token: 0x04001726 RID: 5926
		private static PlayerHooks.HookList HookModifyHitNPCWithProj = PlayerHooks.AddHook<PlayerHooks.DelegateModifyHitNPCWithProj>((ModPlayer p) => (PlayerHooks.DelegateModifyHitNPCWithProj)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateModifyHitNPCWithProj), p, methodof(ModPlayer.ModifyHitNPCWithProj(Projectile, NPC, int*, float*, bool*, int*))));

		// Token: 0x04001727 RID: 5927
		private static PlayerHooks.HookList HookOnHitNPCWithProj = PlayerHooks.AddHook<Action<Projectile, NPC, int, float, bool>>((ModPlayer p) => (Action<Projectile, NPC, int, float, bool>)Delegate.CreateDelegate(typeof(Action<Projectile, NPC, int, float, bool>), p, methodof(ModPlayer.OnHitNPCWithProj(Projectile, NPC, int, float, bool))));

		// Token: 0x04001728 RID: 5928
		private static PlayerHooks.HookList HookCanHitPvp = PlayerHooks.AddHook<Func<Item, Player, bool>>((ModPlayer p) => (Func<Item, Player, bool>)Delegate.CreateDelegate(typeof(Func<Item, Player, bool>), p, methodof(ModPlayer.CanHitPvp(Item, Player))));

		// Token: 0x04001729 RID: 5929
		private static PlayerHooks.HookList HookModifyHitPvp = PlayerHooks.AddHook<PlayerHooks.DelegateModifyHitPvp>((ModPlayer p) => (PlayerHooks.DelegateModifyHitPvp)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateModifyHitPvp), p, methodof(ModPlayer.ModifyHitPvp(Item, Player, int*, bool*))));

		// Token: 0x0400172A RID: 5930
		private static PlayerHooks.HookList HookOnHitPvp = PlayerHooks.AddHook<Action<Item, Player, int, bool>>((ModPlayer p) => (Action<Item, Player, int, bool>)Delegate.CreateDelegate(typeof(Action<Item, Player, int, bool>), p, methodof(ModPlayer.OnHitPvp(Item, Player, int, bool))));

		// Token: 0x0400172B RID: 5931
		private static PlayerHooks.HookList HookCanHitPvpWithProj = PlayerHooks.AddHook<Func<Projectile, Player, bool>>((ModPlayer p) => (Func<Projectile, Player, bool>)Delegate.CreateDelegate(typeof(Func<Projectile, Player, bool>), p, methodof(ModPlayer.CanHitPvpWithProj(Projectile, Player))));

		// Token: 0x0400172C RID: 5932
		private static PlayerHooks.HookList HookModifyHitPvpWithProj = PlayerHooks.AddHook<PlayerHooks.DelegateModifyHitPvpWithProj>((ModPlayer p) => (PlayerHooks.DelegateModifyHitPvpWithProj)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateModifyHitPvpWithProj), p, methodof(ModPlayer.ModifyHitPvpWithProj(Projectile, Player, int*, bool*))));

		// Token: 0x0400172D RID: 5933
		private static PlayerHooks.HookList HookOnHitPvpWithProj = PlayerHooks.AddHook<Action<Projectile, Player, int, bool>>((ModPlayer p) => (Action<Projectile, Player, int, bool>)Delegate.CreateDelegate(typeof(Action<Projectile, Player, int, bool>), p, methodof(ModPlayer.OnHitPvpWithProj(Projectile, Player, int, bool))));

		// Token: 0x0400172E RID: 5934
		private static PlayerHooks.HookList HookCanBeHitByNPC = PlayerHooks.AddHook<PlayerHooks.DelegateCanBeHitByNPC>((ModPlayer p) => (PlayerHooks.DelegateCanBeHitByNPC)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateCanBeHitByNPC), p, methodof(ModPlayer.CanBeHitByNPC(NPC, int*))));

		// Token: 0x0400172F RID: 5935
		private static PlayerHooks.HookList HookModifyHitByNPC = PlayerHooks.AddHook<PlayerHooks.DelegateModifyHitByNPC>((ModPlayer p) => (PlayerHooks.DelegateModifyHitByNPC)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateModifyHitByNPC), p, methodof(ModPlayer.ModifyHitByNPC(NPC, int*, bool*))));

		// Token: 0x04001730 RID: 5936
		private static PlayerHooks.HookList HookOnHitByNPC = PlayerHooks.AddHook<Action<NPC, int, bool>>((ModPlayer p) => (Action<NPC, int, bool>)Delegate.CreateDelegate(typeof(Action<NPC, int, bool>), p, methodof(ModPlayer.OnHitByNPC(NPC, int, bool))));

		// Token: 0x04001731 RID: 5937
		private static PlayerHooks.HookList HookCanBeHitByProjectile = PlayerHooks.AddHook<Func<Projectile, bool>>((ModPlayer p) => (Func<Projectile, bool>)Delegate.CreateDelegate(typeof(Func<Projectile, bool>), p, methodof(ModPlayer.CanBeHitByProjectile(Projectile))));

		// Token: 0x04001732 RID: 5938
		private static PlayerHooks.HookList HookModifyHitByProjectile = PlayerHooks.AddHook<PlayerHooks.DelegateModifyHitByProjectile>((ModPlayer p) => (PlayerHooks.DelegateModifyHitByProjectile)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateModifyHitByProjectile), p, methodof(ModPlayer.ModifyHitByProjectile(Projectile, int*, bool*))));

		// Token: 0x04001733 RID: 5939
		private static PlayerHooks.HookList HookOnHitByProjectile = PlayerHooks.AddHook<Action<Projectile, int, bool>>((ModPlayer p) => (Action<Projectile, int, bool>)Delegate.CreateDelegate(typeof(Action<Projectile, int, bool>), p, methodof(ModPlayer.OnHitByProjectile(Projectile, int, bool))));

		// Token: 0x04001734 RID: 5940
		private static PlayerHooks.HookList HookCatchFish = PlayerHooks.AddHook<PlayerHooks.DelegateCatchFish>((ModPlayer p) => (PlayerHooks.DelegateCatchFish)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateCatchFish), p, methodof(ModPlayer.CatchFish(Item, Item, int, int, int, int, int, int*, bool*))));

		// Token: 0x04001735 RID: 5941
		private static PlayerHooks.HookList HookGetFishingLevel = PlayerHooks.AddHook<PlayerHooks.DelegateGetFishingLevel>((ModPlayer p) => (PlayerHooks.DelegateGetFishingLevel)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateGetFishingLevel), p, methodof(ModPlayer.GetFishingLevel(Item, Item, int*))));

		// Token: 0x04001736 RID: 5942
		private static PlayerHooks.HookList HookAnglerQuestReward = PlayerHooks.AddHook<Action<float, List<Item>>>((ModPlayer p) => (Action<float, List<Item>>)Delegate.CreateDelegate(typeof(Action<float, List<Item>>), p, methodof(ModPlayer.AnglerQuestReward(float, List<Item>))));

		// Token: 0x04001737 RID: 5943
		private static PlayerHooks.HookList HookGetDyeTraderReward = PlayerHooks.AddHook<Action<List<int>>>((ModPlayer p) => (Action<List<int>>)Delegate.CreateDelegate(typeof(Action<List<int>>), p, methodof(ModPlayer.GetDyeTraderReward(List<int>))));

		// Token: 0x04001738 RID: 5944
		private static PlayerHooks.HookList HookDrawEffects = PlayerHooks.AddHook<PlayerHooks.DelegateDrawEffects>((ModPlayer p) => (PlayerHooks.DelegateDrawEffects)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateDrawEffects), p, methodof(ModPlayer.DrawEffects(PlayerDrawInfo, float*, float*, float*, float*, bool*))));

		// Token: 0x04001739 RID: 5945
		private static PlayerHooks.HookList HookModifyDrawInfo = PlayerHooks.AddHook<PlayerHooks.DelegateModifyDrawInfo>((ModPlayer p) => (PlayerHooks.DelegateModifyDrawInfo)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateModifyDrawInfo), p, methodof(ModPlayer.ModifyDrawInfo(PlayerDrawInfo*))));

		// Token: 0x0400173A RID: 5946
		private static PlayerHooks.HookList HookModifyDrawLayers = PlayerHooks.AddHook<Action<List<PlayerLayer>>>((ModPlayer p) => (Action<List<PlayerLayer>>)Delegate.CreateDelegate(typeof(Action<List<PlayerLayer>>), p, methodof(ModPlayer.ModifyDrawLayers(List<PlayerLayer>))));

		// Token: 0x0400173B RID: 5947
		private static PlayerHooks.HookList HookModifyDrawHeadLayers = PlayerHooks.AddHook<Action<List<PlayerHeadLayer>>>((ModPlayer p) => (Action<List<PlayerHeadLayer>>)Delegate.CreateDelegate(typeof(Action<List<PlayerHeadLayer>>), p, methodof(ModPlayer.ModifyDrawHeadLayers(List<PlayerHeadLayer>))));

		// Token: 0x0400173C RID: 5948
		private static PlayerHooks.HookList HookModifyScreenPosition = PlayerHooks.AddHook<Action>((ModPlayer p) => (Action)Delegate.CreateDelegate(typeof(Action), p, methodof(ModPlayer.ModifyScreenPosition())));

		// Token: 0x0400173D RID: 5949
		private static PlayerHooks.HookList HookModifyZoom = PlayerHooks.AddHook<PlayerHooks.DelegateModifyZoom>((ModPlayer p) => (PlayerHooks.DelegateModifyZoom)Delegate.CreateDelegate(typeof(PlayerHooks.DelegateModifyZoom), p, methodof(ModPlayer.ModifyZoom(float*))));

		// Token: 0x0400173E RID: 5950
		private static PlayerHooks.HookList HookPlayerConnect = PlayerHooks.AddHook<Action<Player>>((ModPlayer p) => (Action<Player>)Delegate.CreateDelegate(typeof(Action<Player>), p, methodof(ModPlayer.PlayerConnect(Player))));

		// Token: 0x0400173F RID: 5951
		private static PlayerHooks.HookList HookPlayerDisconnect = PlayerHooks.AddHook<Action<Player>>((ModPlayer p) => (Action<Player>)Delegate.CreateDelegate(typeof(Action<Player>), p, methodof(ModPlayer.PlayerDisconnect(Player))));

		// Token: 0x04001740 RID: 5952
		private static PlayerHooks.HookList HookOnEnterWorld = PlayerHooks.AddHook<Action<Player>>((ModPlayer p) => (Action<Player>)Delegate.CreateDelegate(typeof(Action<Player>), p, methodof(ModPlayer.OnEnterWorld(Player))));

		// Token: 0x04001741 RID: 5953
		private static PlayerHooks.HookList HookOnRespawn = PlayerHooks.AddHook<Action<Player>>((ModPlayer p) => (Action<Player>)Delegate.CreateDelegate(typeof(Action<Player>), p, methodof(ModPlayer.OnRespawn(Player))));

		// Token: 0x04001742 RID: 5954
		private static PlayerHooks.HookList HookShiftClickSlot = PlayerHooks.AddHook<Func<Item[], int, int, bool>>((ModPlayer p) => (Func<Item[], int, int, bool>)Delegate.CreateDelegate(typeof(Func<Item[], int, int, bool>), p, methodof(ModPlayer.ShiftClickSlot(Item[], int, int))));

		// Token: 0x0200025B RID: 603
		private class HookList
		{
			// Token: 0x06001976 RID: 6518 RVA: 0x00012422 File Offset: 0x00010622
			public HookList(MethodInfo method)
			{
				this.method = method;
			}

			// Token: 0x04001743 RID: 5955
			public int[] arr = new int[0];

			// Token: 0x04001744 RID: 5956
			public readonly MethodInfo method;
		}

		// Token: 0x0200025C RID: 604
		// (Invoke) Token: 0x06001978 RID: 6520
		private delegate void DelegateNaturalLifeRegen(ref float regen);

		// Token: 0x0200025D RID: 605
		// (Invoke) Token: 0x0600197C RID: 6524
		private delegate void DelegateUpdateEquips(ref bool wallSpeedBuff, ref bool tileSpeedBuff, ref bool tileRangeBuff);

		// Token: 0x0200025E RID: 606
		// (Invoke) Token: 0x06001980 RID: 6528
		private delegate bool DelegatePreHurt(bool pvp, bool quiet, ref int damage, ref int hitDirection, ref bool crit, ref bool customDamage, ref bool playSound, ref bool genGore, ref PlayerDeathReason damageSource);

		// Token: 0x0200025F RID: 607
		// (Invoke) Token: 0x06001984 RID: 6532
		private delegate bool DelegatePreKill(double damage, int hitDirection, bool pvp, ref bool playSound, ref bool genGore, ref PlayerDeathReason damageSource);

		// Token: 0x02000260 RID: 608
		// (Invoke) Token: 0x06001988 RID: 6536
		private delegate void DelegateGetWeaponDamage(Item item, ref int damage);

		// Token: 0x02000261 RID: 609
		// (Invoke) Token: 0x0600198C RID: 6540
		private delegate void DelegateGetWeaponKnockback(Item item, ref float knockback);

		// Token: 0x02000262 RID: 610
		// (Invoke) Token: 0x06001990 RID: 6544
		private delegate void DelegateGetWeaponCrit(Item item, ref int crit);

		// Token: 0x02000263 RID: 611
		// (Invoke) Token: 0x06001994 RID: 6548
		private delegate bool DelegateShoot(Item item, ref Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack);

		// Token: 0x02000264 RID: 612
		// (Invoke) Token: 0x06001998 RID: 6552
		private delegate void DelegateModifyHitNPC(Item item, NPC target, ref int damage, ref float knockback, ref bool crit);

		// Token: 0x02000265 RID: 613
		// (Invoke) Token: 0x0600199C RID: 6556
		private delegate void DelegateModifyHitNPCWithProj(Projectile proj, NPC target, ref int damage, ref float knockback, ref bool crit, ref int hitDirection);

		// Token: 0x02000266 RID: 614
		// (Invoke) Token: 0x060019A0 RID: 6560
		private delegate void DelegateModifyHitPvp(Item item, Player target, ref int damage, ref bool crit);

		// Token: 0x02000267 RID: 615
		// (Invoke) Token: 0x060019A4 RID: 6564
		private delegate void DelegateModifyHitPvpWithProj(Projectile proj, Player target, ref int damage, ref bool crit);

		// Token: 0x02000268 RID: 616
		// (Invoke) Token: 0x060019A8 RID: 6568
		private delegate bool DelegateCanBeHitByNPC(NPC npc, ref int cooldownSlot);

		// Token: 0x02000269 RID: 617
		// (Invoke) Token: 0x060019AC RID: 6572
		private delegate void DelegateModifyHitByNPC(NPC npc, ref int damage, ref bool crit);

		// Token: 0x0200026A RID: 618
		// (Invoke) Token: 0x060019B0 RID: 6576
		private delegate void DelegateModifyHitByProjectile(Projectile proj, ref int damage, ref bool crit);

		// Token: 0x0200026B RID: 619
		// (Invoke) Token: 0x060019B4 RID: 6580
		private delegate void DelegateCatchFish(Item fishingRod, Item bait, int power, int liquidType, int poolSize, int worldLayer, int questFish, ref int caughtType, ref bool junk);

		// Token: 0x0200026C RID: 620
		// (Invoke) Token: 0x060019B8 RID: 6584
		private delegate void DelegateGetFishingLevel(Item fishingRod, Item bait, ref int fishingLevel);

		// Token: 0x0200026D RID: 621
		// (Invoke) Token: 0x060019BC RID: 6588
		private delegate void DelegateDrawEffects(PlayerDrawInfo drawInfo, ref float r, ref float g, ref float b, ref float a, ref bool fullBright);

		// Token: 0x0200026E RID: 622
		// (Invoke) Token: 0x060019C0 RID: 6592
		private delegate void DelegateModifyDrawInfo(ref PlayerDrawInfo drawInfo);

		// Token: 0x0200026F RID: 623
		// (Invoke) Token: 0x060019C4 RID: 6596
		private delegate void DelegateModifyZoom(ref float zoom);
	}
}
